home *** CD-ROM | disk | FTP | other *** search
/ Aminet 48 / Aminet 48 (2002)(GTI - Schatztruhe)[!][Apr 2002].iso / Aminet / util / moni / Scout-src.lha / source / objects / scout_screenmode.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-02-13  |  19.0 KB  |  507 lines
  1. /**
  2.  * Scout - The Amiga System Monitor
  3.  *
  4.  *------------------------------------------------------------------
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2 of the License, or
  9.  * any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software
  18.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  *
  20.  * You must not use this source code to gain profit of any kind!
  21.  *
  22.  *------------------------------------------------------------------
  23.  *
  24.  * @author Andreas Gelhausen
  25.  * @author Richard Körber <rkoerber@gmx.de>
  26.  */
  27.  
  28.  
  29.  
  30. #include "system_headers.h"
  31.  
  32. int  smodecnt;
  33.  
  34. APTR smodemoretext0,smodemoretext1,smodemoretext2,smodemoretext3,smodemoretext4,smodemoretext5;
  35. APTR smodemoretext6,smodemoretext7,smodemoretext8,smodemoretext9,smodemoretext10,smodemoretext11;
  36. APTR smodemoretext12,smodemoretext13,smodemoretext14,smodemoretext15,smodemoretext16,smodemoretext17;
  37. APTR smodemoretext18,smodemoretext19,smodemoretext20;
  38.  
  39. static APTR SModePool = NULL;
  40.  
  41. __asm __saveds LONG smodelist_cmpidfunc (register __a1 struct SModeEntry *se1, register __a2 struct SModeEntry *se2)
  42. {
  43.    return (LONG)(se1->sme_smodeid - se2->sme_smodeid);
  44. }
  45.  
  46. struct Hook smodelist_cmpidhook = {
  47.  {NULL, NULL},
  48.  (ULONG (* )())smodelist_cmpidfunc,
  49.  NULL, NULL
  50. };
  51.  
  52. __asm __saveds LONG smodelist_cmpresfunc (register __a1 struct SModeEntry *se1, register __a2 struct SModeEntry *se2)
  53. {
  54.    long  eins = 0, zwei = 0;
  55.  
  56.    IsDec (se1->sme_width, &eins);
  57.    IsDec (se2->sme_width, &zwei);
  58.    if (eins == zwei) {
  59.       IsDec (se1->sme_height, &eins);
  60.       IsDec (se2->sme_height, &zwei);
  61.       if (eins == zwei) {
  62.          IsDec (se1->sme_depth, &eins);
  63.          IsDec (se2->sme_depth, &zwei);
  64.       }
  65.    }
  66.    return eins - zwei;
  67. }
  68.  
  69. struct Hook smodelist_cmpreshook = {
  70.  {NULL, NULL},
  71.  (ULONG (* )())smodelist_cmpresfunc,
  72.  NULL, NULL
  73. };
  74.  
  75. __asm __saveds LONG smodelist_cmpnamefunc (register __a1 struct SModeEntry *se1, register __a2 struct SModeEntry *se2)
  76. {
  77.    LONG cmp;
  78.  
  79.    cmp = strcmpi(se1->sme_name, se2->sme_name);
  80.    if (cmp == 0) cmp = (LONG)(se1->sme_smodeid - se2->sme_smodeid);
  81.  
  82.    return cmp;
  83. }
  84.  
  85. struct Hook smodelist_cmpnamehook = {
  86.  {NULL, NULL},
  87.  (ULONG (* )())smodelist_cmpnamefunc,
  88.  NULL, NULL
  89. };
  90.  
  91.  
  92. __asm __saveds LONG smodelist_dspfunc(register __a2 char **array, register __a1 struct SModeEntry *smodeentry, register __a0 struct Hook *hook)
  93. {
  94.    if (smodeentry) {
  95.       *array++ = smodeentry->sme_id;
  96.       *array++ = smodeentry->sme_width;
  97.       *array++ = smodeentry->sme_height;
  98.       *array++ = smodeentry->sme_depth;
  99.       *array   = smodeentry->sme_name;
  100.    } else {
  101.       *array++ = ESC "bModeID";
  102.       *array++ = ESC "bWidth";
  103.       *array++ = ESC "bHeight";
  104.       *array++ = ESC "bDepth";
  105.       *array   = ESC "bScreenMode";
  106.    }
  107.    return (0);
  108. }
  109.  
  110. struct Hook smodelist_dsphook = {
  111.  {NULL, NULL},
  112.  (ULONG (* )())smodelist_dspfunc,
  113.  NULL, NULL
  114. };
  115.  
  116. void FreeSMode (void)
  117. {
  118.     MyFreePoolStructs(&SModePool, smodetext, NULL, smodelist);
  119. }
  120.  
  121. void GetSModeEntry (struct SModeEntry *smentry, ULONG id) {
  122.  
  123.    struct NameInfo idname;
  124.    struct DimensionInfo iddim;
  125.  
  126.    if (! smentry->sme_smodeid) {
  127.       smentry->sme_smodeid = id;
  128.       _sprintf (smentry->sme_id, "$%08lx", id);
  129.    }
  130.  
  131.    GetDisplayInfoData(NULL,(UBYTE *)&iddim,sizeof(struct DimensionInfo),DTAG_DIMS,id);
  132.    _sprintf (smentry->sme_width,  "%5ld" ,iddim.Nominal.MaxX-iddim.Nominal.MinX+1);
  133.    _sprintf (smentry->sme_height, "%5ld" ,iddim.Nominal.MaxY-iddim.Nominal.MinY+1);
  134.    _sprintf (smentry->sme_depth,  "%5ld" ,(iddim.MaxDepth==32 ? 24 : iddim.MaxDepth));
  135.  
  136.    if(GetDisplayInfoData(NULL,(UBYTE *)&idname,sizeof(struct NameInfo),DTAG_NAME,id)) {
  137.       strncpy (smentry->sme_name,idname.Name,DISPLAYNAMELEN);
  138.    } else {
  139.       struct MonitorInfo idmon;
  140.       struct DisplayInfo iddisp;
  141.  
  142.       if(GetDisplayInfoData(NULL,(UBYTE *)&idmon,sizeof(struct MonitorInfo),DTAG_MNTR,id)) {
  143.          if(GetDisplayInfoData(NULL,(UBYTE *)&iddisp,sizeof(struct DisplayInfo),DTAG_DISP,id)) {
  144.             ULONG  prop = iddisp.PropertyFlags;
  145.             WORD   xres = iddim.Nominal.MaxX - iddim.Nominal.MinX;
  146.             STRPTR namebuf = smentry->sme_name;
  147.  
  148.             //? if(idmon.Mspc) ...
  149.  
  150.             NameCopy(namebuf,idmon.Mspc->ms_Node.xln_Name);
  151.             if(namebuf[0]=='E') {
  152.               if(!strcmp(namebuf,"EURO72:")) strcpy(namebuf,"EURO:72Hz ");
  153.               if(!strcmp(namebuf,"EURO36:")) strcpy(namebuf,"EURO:36Hz ");
  154.             }
  155.  
  156.                  if(xres > 1200) strcat(namebuf,"SuperHighRes");
  157.             else if(xres > 600)  strcat(namebuf,"HighRes");
  158.             else if(xres > 300)  strcat(namebuf,"LowRes");
  159.             else                 strcat(namebuf,"ExtraLowRes");
  160.  
  161.             if(prop&DIPF_IS_DUALPF        ) {
  162.                strcat(namebuf," DualPF"   );
  163.                if(prop&DIPF_IS_PF2PRI) strcat(namebuf,"2");
  164.             }
  165.             if(prop&DIPF_IS_HAM           ) strcat(namebuf," HAM"      );
  166.             if(prop&DIPF_IS_EXTRAHALFBRITE) strcat(namebuf," EHB"      );
  167.             if(prop&DIPF_IS_LACE          ) strcat(namebuf," Interlace");
  168.             if(prop&DIPF_IS_SCANDBL       ) strcat(namebuf," DblScan"  );
  169.  
  170.          } else {
  171.             strncpy (smentry->sme_name,idmon.Mspc->ms_Node.xln_Name,DISPLAYNAMELEN);
  172.          }
  173.       } else {
  174.          strcpy(smentry->sme_name," < ??? >");
  175.       }
  176.    }
  177. }
  178.  
  179. int GetSMode (struct SModeEntry **first) {
  180.    struct  SModeEntry   *smentry,*previous = NULL;
  181.  
  182.    int smcnt = 0;
  183.    *first = 0;
  184.  
  185.    if (!SModePool) SModePool = tbCreatePool(MEMF_CLEAR, 4096, 4096);
  186.  
  187.    if (clientstate) {
  188.       if (SendDaemon ("GetSModeList")) {
  189.          while ((smentry = tbAllocPooled(SModePool, sizeof(struct SModeEntry))) \
  190.            && (ReceiveDecodedEntry ((UBYTE *) smentry, sizeof (struct SModeEntry)))) {
  191.             IsHex (smentry->sme_id, (LONG *)&smentry->sme_smodeid);
  192.  
  193.             if (! *first)
  194.                *first = smentry;
  195.             if (previous)
  196.                previous->sme_next = smentry;
  197.  
  198.             smcnt++;
  199.             previous = smentry;
  200.          }
  201.       }
  202.    } else {
  203.       ULONG currid = INVALID_ID;
  204.  
  205.       while((currid=NextDisplayInfo(currid)) != INVALID_ID)
  206.       {
  207.          if(smentry = tbAllocPooled(SModePool, sizeof(struct SModeEntry))) {
  208.             GetSModeEntry(smentry,currid);
  209.  
  210.             if (! *first)
  211.                *first = smentry;
  212.             if (previous)
  213.                previous->sme_next = smentry;
  214.  
  215.             smcnt++;
  216.             previous = smentry;
  217.          }
  218.       }
  219.    }
  220.    return (smcnt);
  221. }
  222.  
  223. void PrintSMode (char *filename) {
  224.    int   i=1;
  225.    BPTR  handle;
  226.    struct SModeEntry *entryp = NULL;
  227.  
  228.    handle = HandlePrintStart (filename);
  229.    if ((handle) && (PrintOneLine (handle, "\n  ModeID    Wdth  Hght  Dpth  ScreenMode\n\n"))) {
  230.       if (! WI_SMode) {
  231.          i = GetSMode (&entryp);
  232.       }
  233.       if (i) {
  234.          for (i=0;;i++) {
  235.             if (WI_SMode)
  236.                DoMethod (smodelist,MUIM_List_GetEntry,i,&entryp);
  237.             if (!entryp) break;
  238.  
  239.             _sprintf (tmpstr2, " %s %5s %5s %2s  %s\n", entryp->sme_id, entryp->sme_width, entryp->sme_height, entryp->sme_depth, entryp->sme_name);
  240.             if (! (PrintOneLine (handle, tmpstr2)))
  241.                break;
  242.  
  243.             if (! WI_SMode)
  244.                entryp = entryp->sme_next;
  245.          }
  246.       }
  247.    }
  248.    HandlePrintStop();
  249. }
  250.  
  251. void ShowSMode (void) {
  252.    struct   SModeEntry   *sm;
  253.  
  254.    ApplicationSleep();
  255.    set(smodelist,MUIA_List_Quiet,TRUE);
  256.    set(smodelist,MUIA_List_CompareHook,smodelist_cmphook_ptr);
  257.    set(BT_SModeMore, MUIA_Disabled, TRUE);
  258.    FreeSMode();
  259.  
  260.    smodecnt = GetSMode (&sm);
  261.  
  262.    while (sm) {
  263.       InsertSortedEntry (smodelist, (APTR *) &sm);
  264.       sm = sm->sme_next;
  265.    }
  266.  
  267.    SetCountText (smodecount, smodecnt);
  268.    AwakeApplication();
  269.    set(smodelist,MUIA_List_Quiet,FALSE);
  270. }
  271.  
  272. void SendSModeList (void) {
  273.    struct   SModeEntry   *sm;
  274.  
  275.    FreeSMode();
  276.    GetSMode (&sm);
  277.  
  278.    while (sm) {
  279.       SendEncodedEntry ((UBYTE *) sm, sizeof (struct SModeEntry));
  280.       sm = sm->sme_next;
  281.    }
  282.    FreeSMode();
  283. }
  284.  
  285. void GetSModeMore (struct SModeEntry *sm) {
  286.    unsigned char     *title = "SCREENMODE: ";
  287.    struct   WinFree  *ptr;
  288.    ULONG    id = sm->sme_smodeid;
  289.    struct   DisplayInfo   iddisp;
  290.    struct   DimensionInfo iddims;
  291.    struct   MonitorInfo   idmntr;
  292.    struct   NameInfo      idname;
  293.  
  294.    GetDisplayInfoData(NULL,(UBYTE *)&iddisp,sizeof(struct DisplayInfo)  ,DTAG_DISP,id);
  295.    GetDisplayInfoData(NULL,(UBYTE *)&iddims,sizeof(struct DimensionInfo),DTAG_DIMS,id);
  296.    GetDisplayInfoData(NULL,(UBYTE *)&idmntr,sizeof(struct MonitorInfo)  ,DTAG_MNTR,id);
  297.  
  298.    if (ptr = AllocWinFree()) {
  299.       ptr->wf_Window = (APTR) WindowObject,
  300.       MUIA_Window_SizeGadget, TRUE,
  301.       MUIA_HelpNode, ScreenModeText,
  302.       MUIA_Window_ID, MakeDetailID('.','S','M','D'),
  303.       WindowContents, VGroup,
  304.          Child, ColGroup(2),
  305.             Child, MyLabel2 ("Name:"),
  306.             Child, smodemoretext0 = MyTextObject(),
  307.             Child, MyLabel2 ("Monitor:"),
  308.             Child, smodemoretext6 = MyTextObject(),
  309.             Child, MyLabel2 ("Compatibility:"),
  310.             Child, HGroup,
  311.                Child, smodemoretext16 = MyTextObject2(),
  312.                Child, MyLabel2 ("="),
  313.                Child, smodemoretext17 = MyTextObject(),
  314.             End,
  315.          End,
  316.          Child, HGroup,
  317.             Child, VGroup,
  318.                Child, MyLabel2 ("ModeID:\nPreferred:"),
  319.                Child, MyLabel2 ("Property:"),
  320.                Child, MyLabel2 ("NotAvail:"),
  321.                Child, MyLabel2 ("PixelSpeed:\nTicks/Pixel:"),
  322.                Child, MyLabel2 ("StdSprites:\nTicks/Pixel:"),
  323.                Child, MyLabel2 ("Palette:\nRGB bits:"),
  324.                Child, MyLabel2 ("MouseTicks:"),
  325.             End,
  326.             Child, VGroup, MUIA_Group_SameWidth, TRUE, MUIA_Weight, 0,
  327.                Child, smodemoretext15 = MyTextObject(),
  328.                Child, smodemoretext1  = KeyButtonF ('l', iddisp.PropertyFlags),
  329.                Child, smodemoretext2  = KeyButtonF ('w', iddisp.NotAvailable),
  330.                Child, smodemoretext3  = MyTextObject(),
  331.                Child, smodemoretext4  = MyTextObject(),
  332.                Child, smodemoretext5  = MyTextObject(),
  333.                Child, smodemoretext20 = MyTextObject(),
  334.             End,
  335.             Child, HSpace(0),
  336.             Child, VGroup,
  337.                Child, MyLabel2 ("MinRaster:\nMaxRaster:"),
  338.                Child, MyLabel2 ("Nominal:\nOffset:"),
  339.                Child, MyLabel2 ("TxtOScan:\nOffset:"),
  340.                Child, MyLabel2 ("StdOScan:\nOffset:"),
  341.                Child, MyLabel2 ("MaxOScan:\nOffset:"),
  342.                Child, MyLabel2 ("VideoOScan:\nOffset:"),
  343.             End,
  344.             Child, VGroup, MUIA_Group_SameWidth, TRUE, MUIA_Weight, 0,
  345.                Child, smodemoretext8  = MyTextObject(),
  346.                Child, smodemoretext9  = MyTextObject(),
  347.                Child, smodemoretext11 = MyTextObject(),
  348.                Child, smodemoretext10 = MyTextObject(),
  349.                Child, smodemoretext13 = MyTextObject(),
  350.                Child, smodemoretext12 = MyTextObject(),
  351.             End,
  352.             Child, HSpace(0),
  353.             Child, VGroup,
  354.                Child, MyLabel2 ("Depth:\nColors:"),
  355.                Child, MyLabel2 ("H freq.:\nV freq.:"),
  356.                Child, MyLabel2 ("TotalRows:\nColorClocks:\n=\nMinRow:"),
  357.                Child, MyLabel2 ("ViewPosition:\nDefault VP:\nViewResolution:\nVP Range min:\nmax:"),
  358.             End,
  359.             Child, VGroup, MUIA_Group_SameWidth, TRUE, MUIA_Weight, 0,
  360.                Child, smodemoretext19 = MyTextObject(),
  361.                Child, smodemoretext18 = MyTextObject(),
  362.                Child, smodemoretext7  = MyTextObject(),
  363.                Child, smodemoretext14 = MyTextObject(),
  364.             End,
  365.          End,
  366.       End, End;
  367.  
  368.       if (ptr->wf_Window) {
  369.          char   colors[20];
  370.          ULONG  fh, fv;
  371.          STRPTR compathelp;
  372.          UWORD  dep  = iddims.MaxDepth;
  373.          ULONG  prop = iddisp.PropertyFlags;
  374.          ULONG  tcc  = idmntr.TotalColorClocks*280;
  375.  
  376.          if(GetDisplayInfoData(NULL,(UBYTE *)&idname,sizeof(struct NameInfo),DTAG_NAME,id)) {
  377.             MySetContents (smodemoretext0, "%s", idname.Name);
  378.          } else {
  379.             MySetContents (smodemoretext0, ESC "8%s", sm->sme_name);
  380.          }
  381.          MySetContents(smodemoretext6,"$%08lx \"%s\" (OpenCnt=%ld)", idmntr.Mspc, idmntr.Mspc->ms_Node.xln_Name, (WORD)idmntr.Mspc->ms_OpenCount);
  382.  
  383.          HandleFlagsButtonPressed(smodemoretext1, ptr, "(SCREENMODE)", "PropertyFlags", prop                , (struct LongFlag *)&dip_flags    , NULL, 'l');
  384.          HandleFlagsButtonPressed(smodemoretext2, ptr, "(SCREENMODE)", "NotAvailable",  iddisp.NotAvailable , (struct LongFlag *)&diavail_flags, NULL, 'w');
  385.  
  386.          fv = 1000000L / (idmntr.TotalColorClocks * 28);
  387.          fh = (fv * 100) / idmntr.TotalRows;
  388.  
  389.          if(prop&DIPF_IS_DUALPF) {
  390.             _sprintf(colors,"2x%ld",1<<(dep>>1));
  391.          } else if(prop&DIPF_IS_HAM) {
  392.             _sprintf(colors,"[%ld]",1<<(3*(dep-2)));
  393.          } else if(dep>24) {
  394.             strcpy(colors,"> 16.8M");
  395.          } else {
  396.             _sprintf(colors,"%ld",1<<dep);
  397.          }
  398.  
  399.          MySetContents(smodemoretext3, ESC "r%ld ns\n%ld x %ld", iddisp.PixelSpeed, iddisp.Resolution.x, iddisp.Resolution.y);
  400.          MySetContents(smodemoretext4, ESC "r%ld\n%ld x %ld", iddisp.NumStdSprites, iddisp.SpriteResolution.x, iddisp.SpriteResolution.y);
  401.          MySetContents(smodemoretext5, ESC "r%ld\n%ld:%ld:%ld", iddisp.PaletteRange, iddisp.RedBits, iddisp.GreenBits, iddisp.BlueBits);
  402.          MySetContents(smodemoretext7, ESC "r%ld\n%ld\n%ld.%03ld µs\n%ld", idmntr.TotalRows, idmntr.TotalColorClocks, tcc/1000, tcc%1000, idmntr.MinRow);
  403.          MySetContents(smodemoretext8, ESC "c%5ld x %5ld\n%5ld x %5ld", iddims.MinRasterWidth, iddims.MinRasterHeight, iddims.MaxRasterWidth, iddims.MaxRasterHeight);
  404.          MySetContents(smodemoretext9, ESC "c%4ld x %4ld\n%4ld x %4ld", iddims.Nominal.MaxX-iddims.Nominal.MinX+1, iddims.Nominal.MaxY-iddims.Nominal.MinY+1, iddims.Nominal.MinX, iddims.Nominal.MinY);
  405.          MySetContents(smodemoretext10, ESC "c%4ld x %4ld\n%4ld x %4ld", iddims.StdOScan.MaxX-iddims.StdOScan.MinX+1, iddims.StdOScan.MaxY-iddims.StdOScan.MinY+1, iddims.StdOScan.MinX, iddims.StdOScan.MinY);
  406.          MySetContents(smodemoretext11, ESC "c%4ld x %4ld\n%4ld x %4ld", iddims.TxtOScan.MaxX-iddims.TxtOScan.MinX+1, iddims.TxtOScan.MaxY-iddims.TxtOScan.MinY+1, iddims.TxtOScan.MinX, iddims.TxtOScan.MinY);
  407.          MySetContents(smodemoretext12, ESC "c%4ld x %4ld\n%4ld x %4ld", iddims.VideoOScan.MaxX-iddims.VideoOScan.MinX+1, iddims.VideoOScan.MaxY-iddims.VideoOScan.MinY+1, iddims.VideoOScan.MinX, iddims.VideoOScan.MinY);
  408.          MySetContents(smodemoretext13, ESC "c%4ld x %4ld\n%4ld x %4ld", iddims.MaxOScan.MaxX-iddims.MaxOScan.MinX+1, iddims.MaxOScan.MaxY-iddims.MaxOScan.MinY+1, iddims.MaxOScan.MinX, iddims.MaxOScan.MinY);
  409.          MySetContents(smodemoretext14, ESC "c%4ld x %4ld\n%4ld x %4ld\n%4ld x %4ld\n%4ld x %4ld\n%4ld x %4ld", idmntr.ViewPosition.x, idmntr.ViewPosition.y, idmntr.DefaultViewPosition.x, idmntr.DefaultViewPosition.y, idmntr.ViewResolution.x, idmntr.ViewResolution.y, idmntr.ViewPositionRange.MinX, idmntr.ViewPositionRange.MinY, idmntr.ViewPositionRange.MaxX, idmntr.ViewPositionRange.MaxY);
  410.          MySetContents(smodemoretext15, ESC "r$%08lx\n$%08lx", id, idmntr.PreferredModeID);
  411.          MySetContents(smodemoretext16, "%2ld", idmntr.Compatibility);
  412.          MySetContents(smodemoretext18, ESC "r%ld kHz\n%ld Hz",fv/10,fh);
  413.          MySetContents(smodemoretext19, ESC "r%ld\n%s",dep,colors);
  414.          MySetContents(smodemoretext20, ESC "r%ld x %ld", idmntr.MouseTicks.x, idmntr.MouseTicks.y);
  415.  
  416.          switch(idmntr.Compatibility)
  417.          {
  418.            case MCOMPAT_MIXED:
  419.               compathelp = "MCOMPAT_MIXED: can share display with other MIXED";
  420.               break;
  421.            case MCOMPAT_SELF:
  422.               compathelp = "MCOMPAT_SELF: can share only within monitor";
  423.               break;
  424.            case MCOMPAT_NOBODY:
  425.               compathelp = "MCOMPAT_NOBODY: only one viewport";
  426.               break;
  427.            default:
  428.               compathelp = ESC "8< ??? >";
  429.          }
  430.          MySetContents(smodemoretext17,"%s",compathelp);
  431.  
  432. //*         MySetContents (smodemoretext3, ESC "r$%08x\n" ESC "c%s\n%d\n" ESC "r$%08x\n$%08x", bc, GetCxNodeType(CxObjType((CxObj *)bc)),bc->mco_Node.ln_Pri, bc->mco_Task, bc->mco_Port);
  433. //*         MySetContentsHealed (cxmoretext5, "%s", nonetest (GetTaskName (bc->mco_Task)));
  434.  
  435.          HandleWindowOpen (ptr, title, sm->sme_name);
  436.          HandleWindowClose (ptr);
  437.       }
  438.    }
  439. }
  440.  
  441.  
  442. APTR SModeSortList[] = {
  443.    &smodelist_cmpidhook,
  444.    &smodelist_cmpnamehook,
  445.    &smodelist_cmpreshook,
  446.    NULL
  447. };
  448.  
  449. static const char *CYA_SModeSortText[] = {
  450.    "ModeID",
  451.    "name",
  452.    "resolution",
  453.    NULL
  454. };
  455.  
  456. APTR WI_SMode, smodelist, smodetext, smodecount, CY_SModeSort;
  457. int  smodesortstate = 0;
  458. APTR BT_SModeUpdate, BT_SModePrint, BT_SModeMore, BT_SModeExit;
  459.  
  460. char smode_title[WINDOWTITLELEN];
  461.  
  462. void SModeWindow (BOOL state) {
  463.    if (state) {
  464.       if (WI_SMode) {
  465.          ShowSMode();
  466.       } else {
  467.          WI_SMode = WindowObject,
  468.          MUIA_Window_Title, MyGetWindowTitle (smode_title, "SCREENMODE"),
  469.          MUIA_HelpNode, ScreenModeText,
  470.          MUIA_Window_ID, MakeListID('S','M','D','E'),
  471.          WindowContents, VGroup,
  472.             Child, smodelist = MyListviewObject ("DELTA=8,DELTA=8,DELTA=8,DELTA=8,",&smodelist_dsphook),
  473.             Child, MyBelowSortedListview (&smodetext, &smodecount, &CY_SModeSort, CYA_SModeSortText, smodesortstate),
  474.             Child, MyVSpace(2),
  475.             Child, HGroup, MUIA_Group_SameSize, TRUE,
  476.                Child, BT_SModeUpdate     = KeyButtonA (UpdateText   ,ID_SMODEUPDATE),
  477.                Child, BT_SModePrint      = KeyButtonA (PrintText    ,ID_SMODEPRINT),
  478.                Child, BT_SModeMore       = KeyButtonA (MoreText     ,ID_SMODEMORE),
  479.                Child, BT_SModeExit       = KeyButtonA (ExitText     ,ID_SMODEEXIT),
  480.             End,
  481.          End, End;
  482.  
  483.          if (WI_SMode) {
  484.             DoMethod (AP_Scout,OM_ADDMEMBER,WI_SMode);
  485.             DoMethod (WI_SMode,MUIM_Window_SetCycleChain,smodelist,CY_SModeSort,BT_SModeUpdate,BT_SModePrint,BT_SModeMore,BT_SModeExit,NULL);
  486.             DoMethod (CY_SModeSort, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, AP_Scout, 2, MUIM_Application_ReturnID, ID_SMODESORT);
  487.  
  488.             SetCloseRequest (WI_SMode,ID_SMODEEXIT);
  489.             SetListActive (smodelist,ID_SMODELV_ACTIVE);
  490.             SetListviewDoubleClick (smodelist,ID_SMODEMORE);
  491.  
  492.             ShowSMode();
  493.  
  494.             SetWindowOpen (WI_SMode,smodelist,ID_SMODEEXIT);
  495.          }
  496.       }
  497.    } else if ((! state) && (WI_SMode)) {
  498.       SetWindowClose (WI_SMode,TRUE);
  499.       FreeSMode();
  500.       DoMethod (AP_Scout,OM_REMMEMBER,WI_SMode);
  501.       MUI_DisposeObject (WI_SMode);
  502.       WI_SMode = NULL;
  503.       smodelist = NULL;
  504.    }
  505. }
  506.  
  507.